#include "./SYSTEM/sys/sys.h"
#include "./SYSTEM/usart/usart.h"

/******************************************************************************************/
/* 加入以下代码, 支持printf函数, 而不需要选择use MicroLIB */

#if 1

#if (__ARMCC_VERSION >= 6010050)            /* 使用AC6编译器时 */
__asm(".global __use_no_semihosting\n\t");  /* 声明不使用半主机模式 */
__asm(".global __ARM_use_no_argv \n\t");    /* AC6下需要声明main函数为无参数格式，否则部分例程可能出现半主机模式 */

#else
/* 使用AC5编译器时, 要在这里定义__FILE 和 不使用半主机模式 */
#pragma import(__use_no_semihosting)

struct __FILE
{
    int handle;
    /* Whatever you require here. If the only file you are using is */
    /* standard output using printf() for debugging, no file handling */
    /* is required. */
};

#endif

/* 不使用半主机模式，至少需要重定义_ttywrch\_sys_exit\_sys_command_string函数,以同时兼容AC6和AC5模式 */
int _ttywrch(int ch)
{
    ch = ch;
    return ch;
}

/* 定义_sys_exit()以避免使用半主机模式 */
void _sys_exit(int x)
{
    x = x;
}

char *_sys_command_string(char *cmd, int len)
{
    return NULL;
}


/* FILE 在 stdio.h里面定义. */
FILE __stdout;

/* MDK下需要重定义fputc函数, printf函数最终会通过调用fputc输出字符串到串口 */
int fputc(int ch, FILE *f)
{
    while ((USART1->SR & 0X40) == 0);     /* 等待上一个字符发送完成 */

    USART1->DR = (uint8_t)ch;             /* 将要发送的字符 ch 写入到DR寄存器 */
    return ch;
}
#endif
/******************************************************************************************/
/******************************************************************************************/
#if USART_EN_RX /*如果使能了接收*/

/* 接收缓冲, 最大USART_REC_LEN个字节. */
uint8_t g_usart_rx_buf[USART_REC_LEN];
/*  接收状态
 *  bit15，      接收完成标志
 *  bit14，      接收到0x0d
 *  bit13~0，    接收到的有效字节数目
*/
uint16_t g_usart_rx_sta = 0;
uint8_t g_rx_buffer[RXBUFFERSIZE];  /* HAL库使用的串口接收缓冲 */

UART_HandleTypeDef g_uart3_handle;
UART_HandleTypeDef g_uart1_handle;

uint8_t g_usart_tx_sta =1;
/**
 * @brief       串口X初始化函数
 * @param       baudrate: 波特率, 根据自己需要设置波特率值
 * @note        注意: 必须设置正确的时钟源, 否则串口波特率就会设置异常.
 *              这里的USART的时钟源在sys_stm32_clock_init()函数中已经设置过了.
 * @retval      无
 */
void usart1_init(uint32_t baudrate)
{
    g_uart1_handle.Instance=USART1;
    g_uart1_handle.Init.BaudRate=baudrate;
    g_uart1_handle.Init.HwFlowCtl=UART_HWCONTROL_NONE;
    g_uart1_handle.Init.Mode=UART_MODE_TX_RX;
    g_uart1_handle.Init.Parity=UART_PARITY_NONE;
    g_uart1_handle.Init.StopBits=UART_STOPBITS_1;
    g_uart1_handle.Init.WordLength=UART_WORDLENGTH_8B;

    HAL_UART_Init(&g_uart1_handle);

    HAL_UART_Receive_IT(&g_uart1_handle,(uint8_t *)g_rx_buffer,RXBUFFERSIZE);
}
void usart3_init(uint32_t baudrate)
{
    g_uart3_handle.Instance=USART3;
    g_uart3_handle.Init.BaudRate=baudrate;
    g_uart3_handle.Init.WordLength=UART_WORDLENGTH_8B;
    g_uart3_handle.Init.StopBits=UART_STOPBITS_1;
    g_uart3_handle.Init.Parity = UART_PARITY_NONE;
    g_uart3_handle.Init.HwFlowCtl = UART_HWCONTROL_NONE;
    g_uart3_handle.Init.Mode = UART_MODE_TX_RX;

    HAL_UART_Init(&g_uart3_handle);

    HAL_UART_Receive_IT(&g_uart3_handle,(uint8_t *)g_rx_buffer,RXBUFFERSIZE);
}
/**
 * @brief       UART底层初始化函数
 * @param       huart: UART句柄类型指针
 * @note        此函数会被HAL_UART_Init()调用
 *              完成时钟使能，引脚配置，中断配置
 * @retval      无
 */
void HAL_UART_MspInit(UART_HandleTypeDef *huart)
{
    GPIO_InitTypeDef gpio_init_struct;

    if (huart->Instance ==USART3)
    {
        __HAL_RCC_USART3_CLK_ENABLE();
        __HAL_RCC_GPIOB_CLK_ENABLE();

        gpio_init_struct.Pin = GPIO_PIN_10;
        gpio_init_struct.Mode = GPIO_MODE_AF_PP;
        gpio_init_struct.Pull = GPIO_PULLUP;
        gpio_init_struct.Speed = GPIO_SPEED_FREQ_HIGH;

        HAL_GPIO_Init(GPIOB,&gpio_init_struct);

        gpio_init_struct.Pin=GPIO_PIN_11;
        gpio_init_struct.Mode = GPIO_MODE_INPUT;
        gpio_init_struct.Pull =GPIO_NOPULL;
        HAL_GPIO_Init(GPIOB,&gpio_init_struct);
        /* code */

        HAL_NVIC_EnableIRQ(USART3_IRQn);
        HAL_NVIC_SetPriority(USART3_IRQn,3,3);
    }
    else if (huart->Instance ==USART1)
    {
        __HAL_RCC_USART1_CLK_ENABLE();
        __HAL_RCC_GPIOA_CLK_ENABLE();

        gpio_init_struct.Pin=GPIO_PIN_9;
        gpio_init_struct.Mode=GPIO_MODE_AF_PP;
        gpio_init_struct.Pull=GPIO_PULLUP;
        gpio_init_struct.Speed=GPIO_SPEED_FREQ_HIGH;

        HAL_GPIO_Init(GPIOA,&gpio_init_struct);

        gpio_init_struct.Pin=GPIO_PIN_10;
        gpio_init_struct.Mode=GPIO_MODE_INPUT;
        gpio_init_struct.Pull=GPIO_NOPULL;
        HAL_GPIO_Init(GPIOA,&gpio_init_struct);

        HAL_NVIC_EnableIRQ(USART1_IRQn);
        HAL_NVIC_SetPriority(USART1_IRQn,2,2);
        /* code */
    }
    
    
}

/**
 * @brief       串口数据接收回调函数
                数据处理在这里进行
 * @param       huart:串口句柄
 * @retval      无
 */
void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
{
    if (huart->Instance==USART3)
    {
        if ((g_usart_rx_sta & 0x8000) == 0)             /* 接收未完成 */
        {
            if (g_usart_rx_sta & 0x4000)                /* 接收到了0x0d（即回车键） */
            {
                if (g_rx_buffer[0] != 0x0a)             /* 接收到的不是0x0a（即不是换行键） */
                {
                    g_usart_rx_sta = 0;                 /* 接收错误,重新开始 */
                }
                else                                    /* 接收到的是0x0a（即换行键） */
                {
                    g_usart_rx_sta|= 0x8000;           /* 接收完成了 */
                }
            }
            else                                        /* 还没收到0X0d（即回车键） */
            {
                if (g_rx_buffer[0] == 0x0d)
                    g_usart_rx_sta |= 0x4000;
                else
                {
                    g_usart_rx_buf[g_usart_rx_sta & 0X3FFF] = g_rx_buffer[0];
                    g_usart_rx_sta++;

                    if (g_usart_rx_sta > (USART_REC_LEN - 1))
                    {
                        g_usart_rx_sta = 0;             /* 接收数据错误,重新开始接收 */
                    }
                }
            }
        }
        HAL_UART_Receive_IT(&g_uart3_handle,(uint8_t *)g_rx_buffer,RXBUFFERSIZE);
        /* code */
    }
    else if (huart->Instance==USART1)
    {
        if ((g_usart_rx_sta & 0x8000) == 0)             /* 接收未完成 */
        {
            if (g_usart_rx_sta & 0x4000)                /* 接收到了0x0d（即回车键） */
            {
                if (g_rx_buffer[0] != 0x0a)             /* 接收到的不是0x0a（即不是换行键） */
                {
                    g_usart_rx_sta = 0;                 /* 接收错误,重新开始 */
                }
                else                                    /* 接收到的是0x0a（即换行键） */
                {
                    g_usart_rx_sta|= 0x8000;           /* 接收完成了 */
                }
            }
            else                                        /* 还没收到0X0d（即回车键） */
            {
                if (g_rx_buffer[0] == 0x0d)
                    g_usart_rx_sta |= 0x4000;
                else
                {
                    g_usart_rx_buf[g_usart_rx_sta & 0X3FFF] = g_rx_buffer[0];
                    g_usart_rx_sta++;

                    if (g_usart_rx_sta > (USART_REC_LEN - 1))
                    {
                        g_usart_rx_sta = 0;             /* 接收数据错误,重新开始接收 */
                    }
                }
            }
        }
        HAL_UART_Receive_IT(&g_uart1_handle,(uint8_t *)g_rx_buffer,RXBUFFERSIZE);
        /* code */
    }
    
}

//串口发送回调函数
void HAL_UART_TxCpltCallback(UART_HandleTypeDef *huart)
{
    if (huart->Instance==USART1)
    {
        g_usart_tx_sta=1;
        /* code */
    }
}

void UART_printf(UART_HandleTypeDef *huart ,char *format,...)
{
    char buffer[200];
    va_list args;
    va_start(args,format);
    uint16_t len =vsnprintf(buffer,sizeof(buffer),format,args);
    va_end(args);
 
    uint32_t start =HAL_GetTick();
    while (!g_usart_tx_sta)
    {
        if (HAL_GetTick()-start>200)
        {
            break;
            /* code */
        }
        /* code */
    }
    g_usart_tx_sta =0;
    HAL_UART_Transmit_IT(huart,(uint8_t *)buffer,len);
    
}

void USART1_IRQHandler(void)
{
    HAL_UART_IRQHandler(&g_uart1_handle);
}

void USART3_IRQHandler(void)
{
    HAL_UART_IRQHandler(&g_uart3_handle);
}
#endif
